<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>递归</title>
  </head>
  <body>
    <!-- 作业1 -->
    <!-- <script>
      function Foo() {
        getName = function () {
          alert(1);
        };
        return this;
      }
      Foo.getName = function () {
        alert(2);
      };
      Foo.prototype.getName = function () {
        alert(3);
      };
      var getName = function () {
        alert(4);
      };
      function getName1() {
        alert(5);
      }
      //请写出以下输出结果：
      Foo.getName(); //2 Foo.getName 是一个静态方法，直接调用 Foo.getName() 会执行 Foo
      getName(); //4 getName 是一个全局函数，定义为 alert(4)。所以调用 getName() 会输出 4
      Foo().getName(); //1 当 Foo 被调用时，它执行了内部的函数，重新定义了全局的 getName 为 alert(1)。因此，Foo() 之后调用 getName 会输出 1。
      getName(); //1 由于 Foo() 已经重新定义了 getName，全局的 getName 已经被设置为 alert(1)。因此再调用 getName() 会输出 1。
      new Foo.getName(); //2 这里的 Foo.getName 是一个静态方法，并且 new 操作符在这种情况下并不会影响静态方法的行为。Foo.getName 仍然是 alert(2)。
      new Foo().getName(); //3 new Foo() 创建了一个 Foo 实例，而 Foo.prototype.getName 定义了实例方法 getName，它会输出 3。
      new new Foo().getName(); //3 new (new Foo().getName()) 实际上是对 new Foo().getName 的结果应用 new 操作符，但是 getName 本身是一个方法，并不是构造函数，因此这里的 new 不会改变它的行为，它仍然输出 3。
    </script> -->

    <!-- 作业2 -->
    <!-- <script>
      var fullname = "John Doe";
      var obj = {
        fullname: "Colin Ihrig",
        prop: {
          fullname: "Aurelio De Rosa",
          getFullname: function () {
            return this.fullname;
          },
        },
      };
      // this的指向是obj.prop
      console.log(obj.prop.getFullname()); //Aurelio De Rosa
      //this的指向是window
      var test = obj.prop.getFullname; //John Doe
      console.log(test());
    </script> -->

    <!-- 作业3 -->
    <!-- <script>
      var name = 222;
      var a = {
        name: 111,
        say: function () {
          console.log(this.name);
        },
      };
      var fun = a.say;
      fun();
      a.say();
      var b = {
        name: 333,
        say: function (fn) {
          fn();
        },
      };
      b.say(a.say); //222
      b.say = a.say; //111 222
      // b.say 是 a.say 的引用，但它在 b 的上下文中调用，this 指向 b，因此 b.name 的值 333 被打印。
      b.say(); //333
    </script> -->

    <!-- 作业4 -->
    <!-- <script>
      window.foo = 123;
      function print() {
        this.foo = 234;
        console.log(this);
        console.log(window.foo);
      }
      window.print();
      //Window   this指向windew
      //234   本来是123 后来被改成234
    </script> -->

    <!-- 作业5 -->
    <!-- <script>
      a = 1;
      function foo() {
        console.log(this.a);
      }
      const obj = {
        a: 10,
        bar() {
          foo(); // 1
        },
      };
      obj.bar();//bar的指向是obj  foo的指向是window
    </script> -->

    <!-- 作业6 -->
    <!-- <script>
      var a = 1;
      function outer() {
        var a = 2;
        function inner() {
          console.log(this.a); // 1
        }
        inner();
      }
      outer();//1  函数调用指向window
    </script> -->

    <!-- 作业7 -->
    <!-- <script>
      var obj = {
        a: 1,
        foo() {
          console.log(this.a);
        },
      };
      var a = 2;
      var foo = obj.foo;
      var obj2 = { a: 3, foo: obj.foo };
      obj.foo(); //1
      foo(); //2
      obj2.foo();//3
    </script> -->
  </body>
</html>
